/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package DAO;

import Modelo.*;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

/**
 *
 * @author Isadora
 */
public class DAO<T>  {
    private EntityManager em;
    private final Class<T> classe;
    
    public DAO(EntityManager em, Class<T> classe){
        this.em = em;
        this.classe = classe;
    }
    
    public void salvar(T classe){
        em.persist(classe);
    }
    
    public String retornas(String login,String senha) throws Exception{
        String resultado = "";
        try{
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<String> criteria = builder.createQuery(String.class);
        Root<T> root = criteria.from(classe);
        criteria.select(root.<String>get("login"));
        Predicate conjunction = builder.conjunction();
        conjunction = builder.and(conjunction,builder.like(root.<String>get("login"),login));
        conjunction = builder.and(conjunction,builder.like(root.<String>get("senha"),senha));
        criteria.where(conjunction);
        resultado = this.em.createQuery(criteria).getSingleResult();
        }
        catch(Exception e){
         return resultado;  
        }
        return resultado;  
    }
    
    public Usuario retornaUsuario(String login,String senha) throws Exception{
        Usuario resultado = new Usuario();
        try{
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<Usuario> criteria = builder.createQuery(Usuario.class);
        Root<T> root = criteria.from(classe);
        //criteria.select(root.<String>get("login"));
        Predicate conjunction = builder.conjunction();
        conjunction = builder.and(conjunction,builder.like(root.<String>get("login"),login));
        conjunction = builder.and(conjunction,builder.like(root.<String>get("senha"),senha));
        criteria.where(conjunction);
        resultado = this.em.createQuery(criteria).getSingleResult();
        }
        catch(Exception e){
         return resultado;  
        }
        return resultado; 
    }
    
     public Classificacao retornaClassificacao( int id) throws Exception{
        Classificacao resultado = new Classificacao();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<Classificacao> criteria = builder.createQuery(Classificacao.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);
            resultado = (Classificacao) q.getSingleResult();
           // if (resultado.equals(null))
               // return "nao achou";
            //return "achou";
            return resultado;
        }
        catch(Exception e){
           // return "nao achou";  
            return resultado;
        }
    }
     
    public ItemClassificacao retornaItemClassificacao( int id) throws Exception{
        ItemClassificacao resultado = new ItemClassificacao();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<ItemClassificacao> criteria = builder.createQuery(ItemClassificacao.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (ItemClassificacao) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public Processo retornaProcesso( int id) throws Exception{
        Processo resultado = new Processo();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<Processo> criteria = builder.createQuery(Processo.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (Processo) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public ParametroEstimativa retornaParametroEstimativa( int id) throws Exception{
        ParametroEstimativa resultado = new ParametroEstimativa();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<ParametroEstimativa> criteria = builder.createQuery(ParametroEstimativa.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (ParametroEstimativa) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public Atividade retornaAtividade( int id) throws Exception{
        Atividade resultado = new Atividade();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<Atividade> criteria = builder.createQuery(Atividade.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (Atividade) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public Projeto retornaProjeto( int id) throws Exception{
        Projeto resultado = new Projeto();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<Projeto> criteria = builder.createQuery(Projeto.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (Projeto) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public AtividadeExecutada retornaAtividadeExecutada( int id) throws Exception{
        AtividadeExecutada resultado = new AtividadeExecutada();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<AtividadeExecutada> criteria = builder.createQuery(AtividadeExecutada.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (AtividadeExecutada) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public RegistroExecucao retornaRegistroExecucao( int id) throws Exception{
        RegistroExecucao resultado = new RegistroExecucao();
        try{
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<RegistroExecucao> criteria = builder.createQuery(RegistroExecucao.class);
            Root<T> root = criteria.from(classe);
            criteria.where(builder.equal(root.get("id"), builder.parameter(String.class, "id")));
            TypedQuery q = em.createQuery(criteria);
            q.setParameter("id", id);

        return (RegistroExecucao) q.getSingleResult();
        }
        catch(Exception e){
            return resultado;  
        }
    }
    
    public List<Projeto> retornaProjetos () {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery <Projeto> criteria = builder.createQuery(Projeto.class);
        TypedQuery <Projeto> q = em.createQuery(criteria);      
        return q.getResultList();
    }
    
    
}
